/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package socketsjava;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;
//import java.util.logging.Level;
//import java.util.logging.Logger;

/**
 *
 * @author jonathan
 */
public class Servidor {
    private ObjectOutputStream salida;
    private ObjectInputStream entrada;
    private ServerSocket servidor;
    private Socket conexion;
    private int contador = 1;
    
    static final int puerto=5000;
    
    public Servidor() throws IOException{
        
        new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                //throw new UnsupportedOperationException("Not supported yet.");
                enviarDatos(e.getActionCommand());
                
            }
        };
//        ServerSocket skServidor = new ServerSocket(puerto);
//        System.out.println("Escuchado en el puerto: " +puerto);
//        for (int i = 0; i < 3; i++) {
//            Socket skCliente = skServidor.accept();
//            System.out.println("Sirvo a la cleinte: " +i);
//            OutputStream aux = skCliente.getOutputStream();
//            DataOutputStream flujo = new DataOutputStream(aux);
//            flujo.writeUTF("Hola Cliente "+ i);
//            skCliente.close();
//        }
//        System.out.println("Demasidos cleinte por hoy");
    }
    
    
    public void ejecutarServidor(){
        try {
            servidor = new ServerSocket(puerto, 100);
            while (true) {                
                try {
                    esperarConexion();
                    obtenerFlujos();
                    procesarConexion();
                } catch (EOFException eofe) {
                    System.out.println("Servidor termino Conexion");
                } finally {
                    cerrarConexion();
                    ++contador;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            Servidor s = new Servidor();
            s.ejecutarServidor();
        } catch (IOException ex) {
            Logger.getLogger(Servidor.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    private void enviarDatos(String mensaje) {
        //throw new UnsupportedOperationException("Not yet implemented");
        try {
            salida.writeObject("SERVIDOR>>: " + mensaje);
            salida.flush();
            System.out.println("\nSERVIDOR>>: " + mensaje);
        } catch (IOException ioe) {
            System.out.println("ERROR Enviar datos: " + ioe.getMessage());
        }
    }

    private void esperarConexion() throws IOException {
        //throw new UnsupportedOperationException("Not yet implemented");
        System.out.println("Esperando una coneccion");
        conexion = servidor.accept();
        System.out.println("Conexion "+ contador + " recibida de: " + 
                conexion.getInetAddress().getHostName());
        
    }

    private void obtenerFlujos() throws IOException{
        //throw new UnsupportedOperationException("Not yet implemented");
        salida = new ObjectOutputStream(conexion.getOutputStream());
        salida.flush();
        
        entrada = new ObjectInputStream(conexion.getInputStream());
        //System.out.println("Se recibieron los flujos de entrada y salida");
        
    }

    private void procesarConexion() throws IOException{
        //throw new UnsupportedOperationException("Not yet implemented");
        String mensaje ="Coneccion exitosa";
        enviarDatos(mensaje);
        
        do {            
            try {
                mensaje = (String)entrada.readObject();
                System.out.println(mensaje);
            } catch (ClassNotFoundException cnfe) {
                System.out.println("Se recibio un tipo de dato desconocido");
            }
        } while (!mensaje.equals("CLIENTE>> Terminar"));
    }

    private void cerrarConexion() {
        //throw new UnsupportedOperationException("Not yet implemented");
        System.out.println("Finalizando la conexion");
        
        try {
            salida.close();
            entrada.close();
            conexion.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
